<?xml version='1.0' encoding='UTF-8'?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html>
        <head>
          <title>akka.testkit.TestProbe</title>
          <meta http-equiv="content-type" content="text/html; charset=UTF-8" />
          
      <link type="text/css" media="screen" rel="stylesheet" href="../../lib/template.css" />
      <script type="text/javascript" src="../../lib/jquery.js"></script>
      <script type="text/javascript" src="../../lib/jquery-ui.js"></script>
      <script type="text/javascript" src="../../lib/template.js"></script>
      <script type="text/javascript" src="../../lib/tools.tooltip.js"></script>
    
        </head>
        <body class="type">
      <div id="definition">
        <a title="Go to companion" href="TestProbe$.html"><img src="../../lib/class_to_object_big.png" /></a>
        <p id="owner"><a name="akka" class="extype" href="../package.html">akka</a>.<a name="akka.testkit" class="extype" href="package.html">testkit</a></p>
        <h1><a title="Go to companion" href="TestProbe$.html">TestProbe</a></h1>
      </div>

      <h4 class="signature" id="signature">
      <span class="kind">class</span>
      <span class="symbol">
        <span class="name">TestProbe</span>
        
        <span class="result"> extends <a name="akka.testkit.TestKit" class="extype" href="TestKit.html">TestKit</a></span>
      </span>
      </h4>
      
          <div class="fullcommenttop" id="comment"><div class="comment cmt"><p>TestKit-based probe which allows sending, reception and reply.
</p></div><div class="toggleContainer block">
          <span class="toggle">Linear Supertypes</span>
          <div class="superTypes hiddenContent"><a name="akka.testkit.TestKit" class="extype" href="TestKit.html">TestKit</a>, AnyRef, <span name="scala.Any" class="extype">Any</span></div>
        </div></div>
        

      <div id="template">

        <div id="mbrsel">
          <div id="textfilter"><span class="pre"></span><span class="input"><input accesskey="/" type="text" /></span><span class="post"></span></div>
          <div id="order">
                <span class="filtertype">Ordering</span>
                <ol><li class="alpha in"><span>Alphabetic</span></li><li class="inherit out"><span>By inheritance</span></li></ol>
              </div>
          <div id="ancestors">
                <span class="filtertype">Inherited</span>
                <ol><li class="hideall out"><span>Hide All</span></li>
                <li class="showall in"><span>Show all</span></li></ol>
                <ol id="linearization"><li name="akka.testkit.TestProbe" class="in"><span>TestProbe</span></li><li name="akka.testkit.TestKit" class="in"><span>TestKit</span></li><li name="scala.AnyRef" class="in"><span>AnyRef</span></li><li name="scala.Any" class="in"><span>Any</span></li></ol>
              </div>
          <div id="visbl">
              <span class="filtertype">Visibility</span>
              <ol><li class="public in"><span>Public</span></li><li class="all out"><span>All</span></li></ol>
            </div>
        </div>

        <div class="members" id="constructors">
              <h3>Instance Constructors</h3>
              <ol><li visbl="pub" name="akka.testkit.TestProbe#this" data-isabs="false">
      <a id="this:TestProbe"></a>
      <h4 class="signature">
      <span class="kind">new</span>
      <span class="symbol">
        <span class="name">TestProbe</span>
        
        <span class="params">(<span name="_application">_application: <a name="akka.actor.ActorSystem" class="extype" href="../actor/ActorSystem.html">ActorSystem</a></span>)</span>
      </span>
      </h4>
      
    </li></ol>
            </div>

        

        

        <div class="values members" id="values">
              <h3>Value Members</h3>
              <ol><li visbl="pub" name="scala.AnyRef#!=" data-isabs="false">
      <a id="!=(AnyRef):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">!=</span>
        
        <span class="params">(<span name="arg0">arg0: AnyRef</span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>AnyRef</dd></dl></div>
    </li><li visbl="pub" name="scala.Any#!=" data-isabs="false">
      <a id="!=(Any):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">!=</span>
        
        <span class="params">(<span name="arg0">arg0: <span name="scala.Any" class="extype">Any</span></span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>Any</dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef###" data-isabs="false">
      <a id="##():Int"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">##</span>
        
        <span class="params">()</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>AnyRef → Any</dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#==" data-isabs="false">
      <a id="==(AnyRef):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">==</span>
        
        <span class="params">(<span name="arg0">arg0: AnyRef</span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>AnyRef</dd></dl></div>
    </li><li visbl="pub" name="scala.Any#==" data-isabs="false">
      <a id="==(Any):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">==</span>
        
        <span class="params">(<span name="arg0">arg0: <span name="scala.Any" class="extype">Any</span></span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>Any</dd></dl></div>
    </li><li visbl="pub" name="scala.Any#asInstanceOf" data-isabs="false">
      <a id="asInstanceOf[T0]:T0"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">asInstanceOf</span>
        <span class="tparams">[<span name="T0">T0</span>]</span>
        <span class="result">: T0</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>Any</dd></dl></div>
    </li><li visbl="pub" name="akka.testkit.TestKit#awaitCond" data-isabs="false">
      <a id="awaitCond(⇒ Boolean,Duration,Duration):Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">awaitCond</span>
        
        <span class="params">(<span name="p">p: ⇒ <span name="scala.Boolean" class="extype">Boolean</span></span>, <span name="max">max: <a name="akka.util.Duration" class="extype" href="../util/Duration.html">Duration</a> = <span class="symbol"><span class="name"><a href="../package.html">Duration.Undefined</a></span></span></span>, <span name="interval">interval: <a name="akka.util.Duration" class="extype" href="../util/Duration.html">Duration</a> = <span class="symbol"><span class="name"><a href="../package.html">100.millis</a></span></span></span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <p class="shortcomment cmt">Await until the given condition evaluates to <code>true</code> or the timeout
expires, whichever comes first.</p><div class="fullcomment"><div class="comment cmt"><p>Await until the given condition evaluates to <code>true</code> or the timeout
expires, whichever comes first.</p><p>If no timeout is given, take it from the innermost enclosing <code>within</code>
block.</p><p>Note that the timeout is scaled using Duration.dilated,
which uses the configuration entry &quot;akka.test.timefactor&quot;.
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="akka.testkit.TestKit" class="extype" href="TestKit.html">TestKit</a></dd></dl></div>
    </li><li visbl="prt" name="scala.AnyRef#clone" data-isabs="false">
      <a id="clone():AnyRef"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">clone</span>
        
        <span class="params">()</span><span class="result">: AnyRef</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected[<a name="java.lang" class="extype" href="../../java/lang/package.html">lang</a>] </dd><dt>Definition Classes</dt><dd>AnyRef</dd><dt>Annotations</dt><dd>
                <span class="name">@throws</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#eq" data-isabs="false">
      <a id="eq(AnyRef):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">eq</span>
        
        <span class="params">(<span name="arg0">arg0: AnyRef</span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>AnyRef</dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#equals" data-isabs="false">
      <a id="equals(Any):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">equals</span>
        
        <span class="params">(<span name="arg0">arg0: <span name="scala.Any" class="extype">Any</span></span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef → Any</dd></dl></div>
    </li><li visbl="pub" name="akka.testkit.TestKit#expectMsg" data-isabs="false">
      <a id="expectMsg[T](Duration,T):T"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">expectMsg</span>
        <span class="tparams">[<span name="T">T</span>]</span>
        <span class="params">(<span name="max">max: <a name="akka.util.Duration" class="extype" href="../util/Duration.html">Duration</a></span>, <span name="obj">obj: T</span>)</span><span class="result">: T</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Receive one message from the test actor and assert that it equals the
given object.</p><div class="fullcomment"><div class="comment cmt"><p>Receive one message from the test actor and assert that it equals the
given object. Wait time is bounded by the given duration, with an
AssertionFailure being thrown in case of timeout.
</p></div><dl class="paramcmts block"><dt>returns</dt><dd class="cmt"><p>the received object
</p></dd></dl><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="akka.testkit.TestKit" class="extype" href="TestKit.html">TestKit</a></dd></dl></div>
    </li><li visbl="pub" name="akka.testkit.TestKit#expectMsg" data-isabs="false">
      <a id="expectMsg[T](T):T"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">expectMsg</span>
        <span class="tparams">[<span name="T">T</span>]</span>
        <span class="params">(<span name="obj">obj: T</span>)</span><span class="result">: T</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Same as <code>expectMsg(remaining, obj)</code>, but correctly treating the timeFactor.</p><div class="fullcomment"><div class="comment cmt"><p>Same as <code>expectMsg(remaining, obj)</code>, but correctly treating the timeFactor.
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="akka.testkit.TestKit" class="extype" href="TestKit.html">TestKit</a></dd></dl></div>
    </li><li visbl="pub" name="akka.testkit.TestKit#expectMsgAllClassOf" data-isabs="false">
      <a id="expectMsgAllClassOf[T](Duration,Class[_ &lt;: T]*):Seq[T]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">expectMsgAllClassOf</span>
        <span class="tparams">[<span name="T">T</span>]</span>
        <span class="params">(<span name="max">max: <a name="akka.util.Duration" class="extype" href="../util/Duration.html">Duration</a></span>, <span name="obj">obj: Class[_ &lt;: T]*</span>)</span><span class="result">: Seq[T]</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Receive a number of messages from the test actor matching the given
number of classes and assert that for each given class one is received
which is of that class (equality, not conformance).</p><div class="fullcomment"><div class="comment cmt"><p>Receive a number of messages from the test actor matching the given
number of classes and assert that for each given class one is received
which is of that class (equality, not conformance). This construct is
useful when the order in which the objects are received is not fixed.
Wait time is bounded by the given duration, with an AssertionFailure
being thrown in case of timeout.
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="akka.testkit.TestKit" class="extype" href="TestKit.html">TestKit</a></dd></dl></div>
    </li><li visbl="pub" name="akka.testkit.TestKit#expectMsgAllClassOf" data-isabs="false">
      <a id="expectMsgAllClassOf[T](Class[_ &lt;: T]*):Seq[T]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">expectMsgAllClassOf</span>
        <span class="tparams">[<span name="T">T</span>]</span>
        <span class="params">(<span name="obj">obj: Class[_ &lt;: T]*</span>)</span><span class="result">: Seq[T]</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Same as <code>expectMsgAllClassOf(remaining, obj...)</code>, but correctly treating the timeFactor.</p><div class="fullcomment"><div class="comment cmt"><p>Same as <code>expectMsgAllClassOf(remaining, obj...)</code>, but correctly treating the timeFactor.
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="akka.testkit.TestKit" class="extype" href="TestKit.html">TestKit</a></dd></dl></div>
    </li><li visbl="pub" name="akka.testkit.TestKit#expectMsgAllConformingOf" data-isabs="false">
      <a id="expectMsgAllConformingOf[T](Duration,Class[_ &lt;: T]*):Seq[T]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">expectMsgAllConformingOf</span>
        <span class="tparams">[<span name="T">T</span>]</span>
        <span class="params">(<span name="max">max: <a name="akka.util.Duration" class="extype" href="../util/Duration.html">Duration</a></span>, <span name="obj">obj: Class[_ &lt;: T]*</span>)</span><span class="result">: Seq[T]</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Receive a number of messages from the test actor matching the given
number of classes and assert that for each given class one is received
which conforms to that class (and vice versa).</p><div class="fullcomment"><div class="comment cmt"><p>Receive a number of messages from the test actor matching the given
number of classes and assert that for each given class one is received
which conforms to that class (and vice versa). This construct is useful
when the order in which the objects are received is not fixed.  Wait time
is bounded by the given duration, with an AssertionFailure being thrown in
case of timeout.</p><p>Beware that one object may satisfy all given class constraints, which
may be counter-intuitive.
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="akka.testkit.TestKit" class="extype" href="TestKit.html">TestKit</a></dd></dl></div>
    </li><li visbl="pub" name="akka.testkit.TestKit#expectMsgAllConformingOf" data-isabs="false">
      <a id="expectMsgAllConformingOf[T](Class[_ &lt;: T]*):Seq[T]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">expectMsgAllConformingOf</span>
        <span class="tparams">[<span name="T">T</span>]</span>
        <span class="params">(<span name="obj">obj: Class[_ &lt;: T]*</span>)</span><span class="result">: Seq[T]</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Same as <code>expectMsgAllConformingOf(remaining, obj...)</code>, but correctly treating the timeFactor.</p><div class="fullcomment"><div class="comment cmt"><p>Same as <code>expectMsgAllConformingOf(remaining, obj...)</code>, but correctly treating the timeFactor.
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="akka.testkit.TestKit" class="extype" href="TestKit.html">TestKit</a></dd></dl></div>
    </li><li visbl="pub" name="akka.testkit.TestKit#expectMsgAllOf" data-isabs="false">
      <a id="expectMsgAllOf[T](Duration,T*):Seq[T]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">expectMsgAllOf</span>
        <span class="tparams">[<span name="T">T</span>]</span>
        <span class="params">(<span name="max">max: <a name="akka.util.Duration" class="extype" href="../util/Duration.html">Duration</a></span>, <span name="obj">obj: T*</span>)</span><span class="result">: Seq[T]</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Receive a number of messages from the test actor matching the given
number of objects and assert that for each given object one is received
which equals it and vice versa.</p><div class="fullcomment"><div class="comment cmt"><p>Receive a number of messages from the test actor matching the given
number of objects and assert that for each given object one is received
which equals it and vice versa. This construct is useful when the order in
which the objects are received is not fixed. Wait time is bounded by the
given duration, with an AssertionFailure being thrown in case of timeout.</p><p><pre>
  dispatcher ! SomeWork1()
  dispatcher ! SomeWork2()
  expectMsgAllOf(1 second, Result1(), Result2())
</pre>
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="akka.testkit.TestKit" class="extype" href="TestKit.html">TestKit</a></dd></dl></div>
    </li><li visbl="pub" name="akka.testkit.TestKit#expectMsgAllOf" data-isabs="false">
      <a id="expectMsgAllOf[T](T*):Seq[T]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">expectMsgAllOf</span>
        <span class="tparams">[<span name="T">T</span>]</span>
        <span class="params">(<span name="obj">obj: T*</span>)</span><span class="result">: Seq[T]</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Same as <code>expectMsgAllOf(remaining, obj...)</code>, but correctly treating the timeFactor.</p><div class="fullcomment"><div class="comment cmt"><p>Same as <code>expectMsgAllOf(remaining, obj...)</code>, but correctly treating the timeFactor.
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="akka.testkit.TestKit" class="extype" href="TestKit.html">TestKit</a></dd></dl></div>
    </li><li visbl="pub" name="akka.testkit.TestKit#expectMsgAnyClassOf" data-isabs="false">
      <a id="expectMsgAnyClassOf[C](Duration,Class[_ &lt;: C]*):C"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">expectMsgAnyClassOf</span>
        <span class="tparams">[<span name="C">C</span>]</span>
        <span class="params">(<span name="max">max: <a name="akka.util.Duration" class="extype" href="../util/Duration.html">Duration</a></span>, <span name="obj">obj: Class[_ &lt;: C]*</span>)</span><span class="result">: C</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Receive one message from the test actor and assert that it conforms to
one of the given classes.</p><div class="fullcomment"><div class="comment cmt"><p>Receive one message from the test actor and assert that it conforms to
one of the given classes. Wait time is bounded by the given duration,
with an AssertionFailure being thrown in case of timeout.
</p></div><dl class="paramcmts block"><dt>returns</dt><dd class="cmt"><p>the received object
</p></dd></dl><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="akka.testkit.TestKit" class="extype" href="TestKit.html">TestKit</a></dd></dl></div>
    </li><li visbl="pub" name="akka.testkit.TestKit#expectMsgAnyClassOf" data-isabs="false">
      <a id="expectMsgAnyClassOf[C](Class[_ &lt;: C]*):C"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">expectMsgAnyClassOf</span>
        <span class="tparams">[<span name="C">C</span>]</span>
        <span class="params">(<span name="obj">obj: Class[_ &lt;: C]*</span>)</span><span class="result">: C</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Same as <code>expectMsgAnyClassOf(remaining, obj...)</code>, but correctly treating the timeFactor.</p><div class="fullcomment"><div class="comment cmt"><p>Same as <code>expectMsgAnyClassOf(remaining, obj...)</code>, but correctly treating the timeFactor.
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="akka.testkit.TestKit" class="extype" href="TestKit.html">TestKit</a></dd></dl></div>
    </li><li visbl="pub" name="akka.testkit.TestKit#expectMsgAnyOf" data-isabs="false">
      <a id="expectMsgAnyOf[T](Duration,T*):T"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">expectMsgAnyOf</span>
        <span class="tparams">[<span name="T">T</span>]</span>
        <span class="params">(<span name="max">max: <a name="akka.util.Duration" class="extype" href="../util/Duration.html">Duration</a></span>, <span name="obj">obj: T*</span>)</span><span class="result">: T</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Receive one message from the test actor and assert that it equals one of
the given objects.</p><div class="fullcomment"><div class="comment cmt"><p>Receive one message from the test actor and assert that it equals one of
the given objects. Wait time is bounded by the given duration, with an
AssertionFailure being thrown in case of timeout.
</p></div><dl class="paramcmts block"><dt>returns</dt><dd class="cmt"><p>the received object
</p></dd></dl><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="akka.testkit.TestKit" class="extype" href="TestKit.html">TestKit</a></dd></dl></div>
    </li><li visbl="pub" name="akka.testkit.TestKit#expectMsgAnyOf" data-isabs="false">
      <a id="expectMsgAnyOf[T](T*):T"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">expectMsgAnyOf</span>
        <span class="tparams">[<span name="T">T</span>]</span>
        <span class="params">(<span name="obj">obj: T*</span>)</span><span class="result">: T</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Same as <code>expectMsgAnyOf(remaining, obj...)</code>, but correctly treating the timeFactor.</p><div class="fullcomment"><div class="comment cmt"><p>Same as <code>expectMsgAnyOf(remaining, obj...)</code>, but correctly treating the timeFactor.
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="akka.testkit.TestKit" class="extype" href="TestKit.html">TestKit</a></dd></dl></div>
    </li><li visbl="pub" name="akka.testkit.TestKit#expectMsgClass" data-isabs="false">
      <a id="expectMsgClass[C](Duration,Class[C]):C"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">expectMsgClass</span>
        <span class="tparams">[<span name="C">C</span>]</span>
        <span class="params">(<span name="max">max: <a name="akka.util.Duration" class="extype" href="../util/Duration.html">Duration</a></span>, <span name="c">c: Class[C]</span>)</span><span class="result">: C</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Receive one message from the test actor and assert that it conforms to
the given class.</p><div class="fullcomment"><div class="comment cmt"><p>Receive one message from the test actor and assert that it conforms to
the given class. Wait time is bounded by the given duration, with an
AssertionFailure being thrown in case of timeout.
</p></div><dl class="paramcmts block"><dt>returns</dt><dd class="cmt"><p>the received object
</p></dd></dl><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="akka.testkit.TestKit" class="extype" href="TestKit.html">TestKit</a></dd></dl></div>
    </li><li visbl="pub" name="akka.testkit.TestKit#expectMsgClass" data-isabs="false">
      <a id="expectMsgClass[C](Class[C]):C"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">expectMsgClass</span>
        <span class="tparams">[<span name="C">C</span>]</span>
        <span class="params">(<span name="c">c: Class[C]</span>)</span><span class="result">: C</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Same as <code>expectMsgClass(remaining, c)</code>, but correctly treating the timeFactor.</p><div class="fullcomment"><div class="comment cmt"><p>Same as <code>expectMsgClass(remaining, c)</code>, but correctly treating the timeFactor.
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="akka.testkit.TestKit" class="extype" href="TestKit.html">TestKit</a></dd></dl></div>
    </li><li visbl="pub" name="akka.testkit.TestKit#expectMsgPF" data-isabs="false">
      <a id="expectMsgPF[T](Duration,String)(PartialFunction[Any, T]):T"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">expectMsgPF</span>
        <span class="tparams">[<span name="T">T</span>]</span>
        <span class="params">(<span name="max">max: <a name="akka.util.Duration" class="extype" href="../util/Duration.html">Duration</a> = <span class="symbol"><span class="name"><a href="../package.html">Duration.Undefined</a></span></span></span>, <span name="hint">hint: String = <span class="symbol">&quot;&quot;</span></span>)</span><span class="params">(<span name="f">f: <span name="scala.PartialFunction" class="extype">PartialFunction</span>[<span name="scala.Any" class="extype">Any</span>, T]</span>)</span><span class="result">: T</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Receive one message from the test actor and assert that the given
partial function accepts it.</p><div class="fullcomment"><div class="comment cmt"><p>Receive one message from the test actor and assert that the given
partial function accepts it. Wait time is bounded by the given duration,
with an AssertionFailure being thrown in case of timeout.</p><p>Use this variant to implement more complicated or conditional
processing.
</p></div><dl class="paramcmts block"><dt>returns</dt><dd class="cmt"><p>the received object as transformed by the partial function
</p></dd></dl><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="akka.testkit.TestKit" class="extype" href="TestKit.html">TestKit</a></dd></dl></div>
    </li><li visbl="pub" name="akka.testkit.TestKit#expectMsgType" data-isabs="false">
      <a id="expectMsgType[T](Duration)(Manifest[T]):T"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">expectMsgType</span>
        <span class="tparams">[<span name="T">T</span>]</span>
        <span class="params">(<span name="max">max: <a name="akka.util.Duration" class="extype" href="../util/Duration.html">Duration</a></span>)</span><span class="params">(<span class="implicit">implicit </span><span name="m">m: Manifest[T]</span>)</span><span class="result">: T</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Receive one message from the test actor and assert that it conforms to the
given type (after erasure).</p><div class="fullcomment"><div class="comment cmt"><p>Receive one message from the test actor and assert that it conforms to the
given type (after erasure). Wait time is bounded by the given duration,
with an AssertionFailure being thrown in case of timeout.
</p></div><dl class="paramcmts block"><dt>returns</dt><dd class="cmt"><p>the received object
</p></dd></dl><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="akka.testkit.TestKit" class="extype" href="TestKit.html">TestKit</a></dd></dl></div>
    </li><li visbl="pub" name="akka.testkit.TestKit#expectMsgType" data-isabs="false">
      <a id="expectMsgType[T](Manifest[T]):T"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">expectMsgType</span>
        <span class="tparams">[<span name="T">T</span>]</span>
        <span class="params">(<span class="implicit">implicit </span><span name="m">m: Manifest[T]</span>)</span><span class="result">: T</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Same as <code>expectMsgType[T](remaining)</code>, but correctly treating the timeFactor.</p><div class="fullcomment"><div class="comment cmt"><p>Same as <code>expectMsgType[T](remaining)</code>, but correctly treating the timeFactor.
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="akka.testkit.TestKit" class="extype" href="TestKit.html">TestKit</a></dd></dl></div>
    </li><li visbl="pub" name="akka.testkit.TestKit#expectNoMsg" data-isabs="false">
      <a id="expectNoMsg(Duration):Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">expectNoMsg</span>
        
        <span class="params">(<span name="max">max: <a name="akka.util.Duration" class="extype" href="../util/Duration.html">Duration</a></span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <p class="shortcomment cmt">Assert that no message is received for the specified time.</p><div class="fullcomment"><div class="comment cmt"><p>Assert that no message is received for the specified time.
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="akka.testkit.TestKit" class="extype" href="TestKit.html">TestKit</a></dd></dl></div>
    </li><li visbl="pub" name="akka.testkit.TestKit#expectNoMsg" data-isabs="false">
      <a id="expectNoMsg():Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">expectNoMsg</span>
        
        <span class="params">()</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <p class="shortcomment cmt">Same as <code>expectNoMsg(remaining)</code>, but correctly treating the timeFactor.</p><div class="fullcomment"><div class="comment cmt"><p>Same as <code>expectNoMsg(remaining)</code>, but correctly treating the timeFactor.
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="akka.testkit.TestKit" class="extype" href="TestKit.html">TestKit</a></dd></dl></div>
    </li><li visbl="prt" name="scala.AnyRef#finalize" data-isabs="false">
      <a id="finalize():Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">finalize</span>
        
        <span class="params">()</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>protected[<a name="java.lang" class="extype" href="../../java/lang/package.html">lang</a>] </dd><dt>Definition Classes</dt><dd>AnyRef</dd><dt>Annotations</dt><dd>
                <span class="name">@throws</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="akka.testkit.TestKit#fishForMessage" data-isabs="false">
      <a id="fishForMessage(Duration,String)(PartialFunction[Any, Boolean]):Any"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">fishForMessage</span>
        
        <span class="params">(<span name="max">max: <a name="akka.util.Duration" class="extype" href="../util/Duration.html">Duration</a> = <span class="symbol"><span class="name"><a href="../package.html">Duration.Undefined</a></span></span></span>, <span name="hint">hint: String = <span class="symbol">&quot;&quot;</span></span>)</span><span class="params">(<span name="f">f: <span name="scala.PartialFunction" class="extype">PartialFunction</span>[<span name="scala.Any" class="extype">Any</span>, <span name="scala.Boolean" class="extype">Boolean</span>]</span>)</span><span class="result">: <span name="scala.Any" class="extype">Any</span></span>
      </span>
      </h4>
      <p class="shortcomment cmt">Hybrid of expectMsgPF and receiveWhile: receive messages while the
partial function matches and returns false.</p><div class="fullcomment"><div class="comment cmt"><p>Hybrid of expectMsgPF and receiveWhile: receive messages while the
partial function matches and returns false. Use it to ignore certain
messages while waiting for a specific message.
</p></div><dl class="paramcmts block"><dt>returns</dt><dd class="cmt"><p>the last received messsage, i.e. the first one for which the
        partial function returned true
</p></dd></dl><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="akka.testkit.TestKit" class="extype" href="TestKit.html">TestKit</a></dd></dl></div>
    </li><li visbl="pub" name="akka.testkit.TestProbe#forward" data-isabs="false">
      <a id="forward(ActorRef,AnyRef):Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">forward</span>
        
        <span class="params">(<span name="actor">actor: <a name="akka.actor.ActorRef" class="extype" href="../actor/ActorRef.html">ActorRef</a></span>, <span name="msg">msg: AnyRef = <span class="symbol"><span class="name"><a href="TestActor$$Message.html#msg:AnyRef">lastMessage.msg</a></span></span></span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <p class="shortcomment cmt">Forward this message as if in the TestActor's receive method with self.</p><div class="fullcomment"><div class="comment cmt"><p>Forward this message as if in the TestActor's receive method with self.forward.
</p></div></div>
    </li><li visbl="pub" name="scala.AnyRef#getClass" data-isabs="false">
      <a id="getClass():java.lang.Class[_]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">getClass</span>
        
        <span class="params">()</span><span class="result">: java.lang.Class[_]</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>AnyRef → Any</dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#hashCode" data-isabs="false">
      <a id="hashCode():Int"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">hashCode</span>
        
        <span class="params">()</span><span class="result">: <span name="scala.Int" class="extype">Int</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef → Any</dd></dl></div>
    </li><li visbl="pub" name="akka.testkit.TestKit#ignoreMsg" data-isabs="false">
      <a id="ignoreMsg(PartialFunction[AnyRef, Boolean]):Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">ignoreMsg</span>
        
        <span class="params">(<span name="f">f: <span name="scala.PartialFunction" class="extype">PartialFunction</span>[AnyRef, <span name="scala.Boolean" class="extype">Boolean</span>]</span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <p class="shortcomment cmt">Ignore all messages in the test actor for which the given partial
function returns true.</p><div class="fullcomment"><div class="comment cmt"><p>Ignore all messages in the test actor for which the given partial
function returns true.
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="akka.testkit.TestKit" class="extype" href="TestKit.html">TestKit</a></dd></dl></div>
    </li><li visbl="pub" name="akka.testkit.TestKit#ignoreNoMsg" data-isabs="false">
      <a id="ignoreNoMsg():Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">ignoreNoMsg</span>
        
        <span class="params">()</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <p class="shortcomment cmt">Stop ignoring messages in the test actor.</p><div class="fullcomment"><div class="comment cmt"><p>Stop ignoring messages in the test actor.
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="akka.testkit.TestKit" class="extype" href="TestKit.html">TestKit</a></dd></dl></div>
    </li><li visbl="pub" name="scala.Any#isInstanceOf" data-isabs="false">
      <a id="isInstanceOf[T0]:Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">isInstanceOf</span>
        <span class="tparams">[<span name="T0">T0</span>]</span>
        <span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>Any</dd></dl></div>
    </li><li visbl="pub" name="akka.testkit.TestKit#lastSender" data-isabs="false">
      <a id="lastSender:ActorRef"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">lastSender</span>
        
        <span class="result">: <a name="akka.actor.ActorRef" class="extype" href="../actor/ActorRef.html">ActorRef</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="akka.testkit.TestKit" class="extype" href="TestKit.html">TestKit</a></dd></dl></div>
    </li><li visbl="pub" name="akka.testkit.TestKit#msgAvailable" data-isabs="false">
      <a id="msgAvailable:Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">msgAvailable</span>
        
        <span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <p class="shortcomment cmt">Query queue status.</p><div class="fullcomment"><div class="comment cmt"><p>Query queue status.
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="akka.testkit.TestKit" class="extype" href="TestKit.html">TestKit</a></dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#ne" data-isabs="false">
      <a id="ne(AnyRef):Boolean"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">ne</span>
        
        <span class="params">(<span name="arg0">arg0: AnyRef</span>)</span><span class="result">: <span name="scala.Boolean" class="extype">Boolean</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>AnyRef</dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#notify" data-isabs="false">
      <a id="notify():Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">notify</span>
        
        <span class="params">()</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>AnyRef</dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#notifyAll" data-isabs="false">
      <a id="notifyAll():Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">notifyAll</span>
        
        <span class="params">()</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>AnyRef</dd></dl></div>
    </li><li visbl="pub" name="akka.testkit.TestKit#now" data-isabs="false">
      <a id="now:Duration"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">now</span>
        
        <span class="result">: <a name="akka.util.Duration" class="extype" href="../util/Duration.html">Duration</a></span>
      </span>
      </h4>
      <p class="shortcomment cmt">Obtain current time (<code>System.nanoTime</code>) as Duration.</p><div class="fullcomment"><div class="comment cmt"><p>Obtain current time (<code>System.nanoTime</code>) as Duration.
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="akka.testkit.TestKit" class="extype" href="TestKit.html">TestKit</a></dd></dl></div>
    </li><li visbl="pub" name="akka.testkit.TestKit#receiveN" data-isabs="false">
      <a id="receiveN(Int,Duration):Seq[AnyRef]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">receiveN</span>
        
        <span class="params">(<span name="n">n: <span name="scala.Int" class="extype">Int</span></span>, <span name="max">max: <a name="akka.util.Duration" class="extype" href="../util/Duration.html">Duration</a></span>)</span><span class="result">: Seq[AnyRef]</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Receive N messages in a row before the given deadline.</p><div class="fullcomment"><div class="comment cmt"><p>Receive N messages in a row before the given deadline.
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="akka.testkit.TestKit" class="extype" href="TestKit.html">TestKit</a></dd></dl></div>
    </li><li visbl="pub" name="akka.testkit.TestKit#receiveN" data-isabs="false">
      <a id="receiveN(Int):Seq[AnyRef]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">receiveN</span>
        
        <span class="params">(<span name="n">n: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: Seq[AnyRef]</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Same as <code>receiveN(n, remaining)</code> but correctly taking into account
Duration.</p><div class="fullcomment"><div class="comment cmt"><p>Same as <code>receiveN(n, remaining)</code> but correctly taking into account
Duration.timeFactor.
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="akka.testkit.TestKit" class="extype" href="TestKit.html">TestKit</a></dd></dl></div>
    </li><li visbl="pub" name="akka.testkit.TestKit#receiveOne" data-isabs="false">
      <a id="receiveOne(Duration):AnyRef"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">receiveOne</span>
        
        <span class="params">(<span name="max">max: <a name="akka.util.Duration" class="extype" href="../util/Duration.html">Duration</a></span>)</span><span class="result">: AnyRef</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Receive one message from the internal queue of the TestActor.</p><div class="fullcomment"><div class="comment cmt"><p>Receive one message from the internal queue of the TestActor. If the given
duration is zero, the queue is polled (non-blocking).</p><p>This method does NOT automatically scale its Duration parameter!
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="akka.testkit.TestKit" class="extype" href="TestKit.html">TestKit</a></dd></dl></div>
    </li><li visbl="pub" name="akka.testkit.TestKit#receiveWhile" data-isabs="false">
      <a id="receiveWhile[T](Duration,Duration,Int)(PartialFunction[AnyRef, T]):Seq[T]"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">receiveWhile</span>
        <span class="tparams">[<span name="T">T</span>]</span>
        <span class="params">(<span name="max">max: <a name="akka.util.Duration" class="extype" href="../util/Duration.html">Duration</a> = <span class="symbol"><span class="name"><a href="../package.html">Duration.Undefined</a></span></span></span>, <span name="idle">idle: <a name="akka.util.Duration" class="extype" href="../util/Duration.html">Duration</a> = <span class="symbol"><span class="name"><a href="../package.html">Duration.Inf</a></span></span></span>, <span name="messages">messages: <span name="scala.Int" class="extype">Int</span> = <span class="symbol"><span class="name"><a href="../../scala/package.html">Int.MaxValue</a></span></span></span>)</span><span class="params">(<span name="f">f: <span name="scala.PartialFunction" class="extype">PartialFunction</span>[AnyRef, T]</span>)</span><span class="result">: Seq[T]</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Receive a series of messages until one does not match the given partial
function or the idle timeout is met (disabled by default) or the overall
maximum duration is elapsed.</p><div class="fullcomment"><div class="comment cmt"><p>Receive a series of messages until one does not match the given partial
function or the idle timeout is met (disabled by default) or the overall
maximum duration is elapsed. Returns the sequence of messages.</p><p>Note that it is not an error to hit the <code>max</code> duration in this case.</p><p>One possible use of this method is for testing whether messages of
certain characteristics are generated at a certain rate:</p><p><pre>
test ! ScheduleTicks(100 millis)
val series = receiveWhile(750 millis) {
    case Tick(count) => count
}
assert(series == (1 to 7).toList)
</pre>
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="akka.testkit.TestKit" class="extype" href="TestKit.html">TestKit</a></dd></dl></div>
    </li><li visbl="pub" name="akka.testkit.TestProbe#ref" data-isabs="false">
      <a id="ref:ActorRef"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">ref</span>
        
        <span class="result">: <a name="akka.actor.ActorRef" class="extype" href="../actor/ActorRef.html">ActorRef</a></span>
      </span>
      </h4>
      <p class="shortcomment cmt">Shorthand to get the testActor.</p>
    </li><li visbl="pub" name="akka.testkit.TestKit#remaining" data-isabs="false">
      <a id="remaining:Duration"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">remaining</span>
        
        <span class="result">: <a name="akka.util.Duration" class="extype" href="../util/Duration.html">Duration</a></span>
      </span>
      </h4>
      <p class="shortcomment cmt">Obtain time remaining for execution of the innermost enclosing <code>within</code>
block or missing that it returns the properly dilated default for this
case from settings (key &quot;akka.</p><div class="fullcomment"><div class="comment cmt"><p>Obtain time remaining for execution of the innermost enclosing <code>within</code>
block or missing that it returns the properly dilated default for this
case from settings (key &quot;akka.test.single-expect-default&quot;).
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="akka.testkit.TestKit" class="extype" href="TestKit.html">TestKit</a></dd></dl></div>
    </li><li visbl="pub" name="akka.testkit.TestProbe#send" data-isabs="false">
      <a id="send(ActorRef,AnyRef):Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">send</span>
        
        <span class="params">(<span name="actor">actor: <a name="akka.actor.ActorRef" class="extype" href="../actor/ActorRef.html">ActorRef</a></span>, <span name="msg">msg: AnyRef</span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <p class="shortcomment cmt">Send message to an actor while using the probe's TestActor as the sender.</p><div class="fullcomment"><div class="comment cmt"><p>Send message to an actor while using the probe's TestActor as the sender.
Replies will be available for inspection with all of TestKit's assertion
methods.
</p></div></div>
    </li><li visbl="pub" name="akka.testkit.TestProbe#sender" data-isabs="false">
      <a id="sender:ActorRef"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">sender</span>
        
        <span class="result">: <a name="akka.actor.ActorRef" class="extype" href="../actor/ActorRef.html">ActorRef</a></span>
      </span>
      </h4>
      <p class="shortcomment cmt">Get sender of last received message.</p>
    </li><li visbl="pub" name="akka.testkit.TestKit#setAutoPilot" data-isabs="false">
      <a id="setAutoPilot(AutoPilot):Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">setAutoPilot</span>
        
        <span class="params">(<span name="pilot">pilot: <a name="akka.testkit.TestActor.AutoPilot" class="extype" href="TestActor$$AutoPilot.html">AutoPilot</a></span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <p class="shortcomment cmt">Install an AutoPilot to drive the testActor: the AutoPilot will be run
for each received message and can be used to send or forward messages,
etc.</p><div class="fullcomment"><div class="comment cmt"><p>Install an AutoPilot to drive the testActor: the AutoPilot will be run
for each received message and can be used to send or forward messages,
etc. Each invocation must return the AutoPilot for the next round.
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="akka.testkit.TestKit" class="extype" href="TestKit.html">TestKit</a></dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#synchronized" data-isabs="false">
      <a id="synchronized[T0](⇒ T0):T0"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">synchronized</span>
        <span class="tparams">[<span name="T0">T0</span>]</span>
        <span class="params">(<span name="arg0">arg0: ⇒ T0</span>)</span><span class="result">: T0</span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>AnyRef</dd></dl></div>
    </li><li visbl="pub" name="akka.testkit.TestKit#system" data-isabs="false">
      <a id="system:ActorSystem"></a>
      <h4 class="signature">
      <span class="kind">implicit val</span>
      <span class="symbol">
        <span class="name">system</span>
        
        <span class="result">: <a name="akka.actor.ActorSystem" class="extype" href="../actor/ActorSystem.html">ActorSystem</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>implicit </dd><dt>Definition Classes</dt><dd><a name="akka.testkit.TestKit" class="extype" href="TestKit.html">TestKit</a></dd></dl></div>
    </li><li visbl="pub" name="akka.testkit.TestKit#testActor" data-isabs="false">
      <a id="testActor:ActorRef"></a>
      <h4 class="signature">
      <span class="kind">lazy val</span>
      <span class="symbol">
        <span class="name">testActor</span>
        
        <span class="result">: <a name="akka.actor.ActorRef" class="extype" href="../actor/ActorRef.html">ActorRef</a></span>
      </span>
      </h4>
      <p class="shortcomment cmt">ActorRef of the test actor.</p><div class="fullcomment"><div class="comment cmt"><p>ActorRef of the test actor. Access is provided to enable e.g.
registration as message target.
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="akka.testkit.TestKit" class="extype" href="TestKit.html">TestKit</a></dd></dl></div>
    </li><li visbl="pub" name="akka.testkit.TestKit#testKitSettings" data-isabs="false">
      <a id="testKitSettings:TestKitSettings"></a>
      <h4 class="signature">
      <span class="kind">val</span>
      <span class="symbol">
        <span class="name">testKitSettings</span>
        
        <span class="result">: <a name="akka.testkit.TestKitSettings" class="extype" href="TestKitSettings.html">TestKitSettings</a></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="akka.testkit.TestKit" class="extype" href="TestKit.html">TestKit</a></dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#toString" data-isabs="false">
      <a id="toString():String"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">toString</span>
        
        <span class="params">()</span><span class="result">: <span name="java.lang.String" class="extype">String</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Definition Classes</dt><dd>AnyRef → Any</dd></dl></div>
    </li><li visbl="pub" name="akka.testkit.TestKit#unwatch" data-isabs="false">
      <a id="unwatch(ActorRef):Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">unwatch</span>
        
        <span class="params">(<span name="ref">ref: <a name="akka.actor.ActorRef" class="extype" href="../actor/ActorRef.html">ActorRef</a></span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <p class="shortcomment cmt">Have the testActor stop watching someone (i.</p><div class="fullcomment"><div class="comment cmt"><p>Have the testActor stop watching someone (i.e. <code>context.unwatch(...)</code>). Waits until
the Watch message is received back using expectMsg.
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="akka.testkit.TestKit" class="extype" href="TestKit.html">TestKit</a></dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#wait" data-isabs="false">
      <a id="wait():Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">wait</span>
        
        <span class="params">()</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>AnyRef</dd><dt>Annotations</dt><dd>
                <span class="name">@throws</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#wait" data-isabs="false">
      <a id="wait(Long,Int):Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">wait</span>
        
        <span class="params">(<span name="arg0">arg0: <span name="scala.Long" class="extype">Long</span></span>, <span name="arg1">arg1: <span name="scala.Int" class="extype">Int</span></span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>AnyRef</dd><dt>Annotations</dt><dd>
                <span class="name">@throws</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="scala.AnyRef#wait" data-isabs="false">
      <a id="wait(Long):Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">wait</span>
        
        <span class="params">(<span name="arg0">arg0: <span name="scala.Long" class="extype">Long</span></span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <div class="fullcomment"><dl class="attributes block"> <dt>Attributes</dt><dd>final </dd><dt>Definition Classes</dt><dd>AnyRef</dd><dt>Annotations</dt><dd>
                <span class="name">@throws</span><span class="args">()</span>
              
        </dd></dl></div>
    </li><li visbl="pub" name="akka.testkit.TestKit#watch" data-isabs="false">
      <a id="watch(ActorRef):Unit"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">watch</span>
        
        <span class="params">(<span name="ref">ref: <a name="akka.actor.ActorRef" class="extype" href="../actor/ActorRef.html">ActorRef</a></span>)</span><span class="result">: <span name="scala.Unit" class="extype">Unit</span></span>
      </span>
      </h4>
      <p class="shortcomment cmt">Have the testActor watch someone (i.</p><div class="fullcomment"><div class="comment cmt"><p>Have the testActor watch someone (i.e. <code>context.watch(...)</code>). Waits until
the Watch message is received back using expectMsg.
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="akka.testkit.TestKit" class="extype" href="TestKit.html">TestKit</a></dd></dl></div>
    </li><li visbl="pub" name="akka.testkit.TestKit#within" data-isabs="false">
      <a id="within[T](Duration)(⇒ T):T"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">within</span>
        <span class="tparams">[<span name="T">T</span>]</span>
        <span class="params">(<span name="max">max: <a name="akka.util.Duration" class="extype" href="../util/Duration.html">Duration</a></span>)</span><span class="params">(<span name="f">f: ⇒ T</span>)</span><span class="result">: T</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Same as calling <code>within(0 seconds, max)(f)</code>.</p><div class="fullcomment"><div class="comment cmt"><p>Same as calling <code>within(0 seconds, max)(f)</code>.
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="akka.testkit.TestKit" class="extype" href="TestKit.html">TestKit</a></dd></dl></div>
    </li><li visbl="pub" name="akka.testkit.TestKit#within" data-isabs="false">
      <a id="within[T](Duration,Duration)(⇒ T):T"></a>
      <h4 class="signature">
      <span class="kind">def</span>
      <span class="symbol">
        <span class="name">within</span>
        <span class="tparams">[<span name="T">T</span>]</span>
        <span class="params">(<span name="min">min: <a name="akka.util.Duration" class="extype" href="../util/Duration.html">Duration</a></span>, <span name="max">max: <a name="akka.util.Duration" class="extype" href="../util/Duration.html">Duration</a></span>)</span><span class="params">(<span name="f">f: ⇒ T</span>)</span><span class="result">: T</span>
      </span>
      </h4>
      <p class="shortcomment cmt">Execute code block while bounding its execution time between <code>min</code> and
<code>max</code>.</p><div class="fullcomment"><div class="comment cmt"><p>Execute code block while bounding its execution time between <code>min</code> and
<code>max</code>. <code>within</code> blocks may be nested. All methods in this trait which
take maximum wait times are available in a version which implicitly uses
the remaining time governed by the innermost enclosing <code>within</code> block.</p><p>Note that the timeout is scaled using Duration.dilated, which uses the
configuration entry &quot;akka.test.timefactor&quot;, while the min Duration is not.</p><p><pre>
val ret = within(50 millis) {
        test ! "ping"
        expectMsgClass(classOf[String])
      }
</pre>
</p></div><dl class="attributes block"> <dt>Definition Classes</dt><dd><a name="akka.testkit.TestKit" class="extype" href="TestKit.html">TestKit</a></dd></dl></div>
    </li></ol>
            </div>

        

        <div name="akka.testkit.TestKit" class="parent">
              <h3>Inherited from <a name="akka.testkit.TestKit" class="extype" href="TestKit.html">TestKit</a></h3>
            </div><div name="scala.AnyRef" class="parent">
              <h3>Inherited from AnyRef</h3>
            </div><div name="scala.Any" class="parent">
              <h3>Inherited from <span name="scala.Any" class="extype">Any</span></h3>
            </div>

      </div>

      <div id="tooltip"></div>

    </body>
      </html>